# 管道生成器脚本 - 定期生成新的管道对
extends Node2D

# 管道对场景
@export var pipe_pair_scene: PackedScene

# 管道生成配置
@export_group("管道生成设置")
@export var spawn_interval: float = 2.0  # 生成间隔（秒）
@export var spawn_interval_min: float = 1.0  # 最小生成间隔（秒）
@export var spawn_interval_max: float = 4.0  # 最大生成间隔（秒）
@export var use_random_interval: bool = false  # 是否使用随机生成间隔
@export var difficulty_scaling: bool = false  # 是否启用难度递增
@export var difficulty_speed: float = 0.1  # 难度递增速度（每秒减少的间隔）

# 管道生成位置
@export var spawn_x: float = 388.0

# 屏幕边界设置
@export_group("屏幕边界设置")
@export var screen_height: float = 512.0  # 屏幕高度
@export var screen_margin: float = 80.0   # 屏幕边距（增加边距确保安全）
@export var ground_height: float = 400.0  # 地面高度（从屏幕顶部算起）
@export var min_pipe_y: float = 200.0     # 管道最小Y位置（可手动调整）
@export var max_pipe_y: float = 312.0     # 管道最大Y位置（可手动调整）
@export var use_auto_boundary: bool = true # 是否使用自动边界计算
@export var boundary_safety_factor: float = 1.2 # 边界安全系数（1.0=精确，>1.0=更安全）

# 管道Y位置范围（将在运行时动态计算）
var min_y: float = 100.0
var max_y: float = 412.0

# 计时器
var spawn_timer: float = 0.0

# 游戏是否进行中
var is_game_running: bool = true

# 难度递增相关变量
var current_spawn_interval: float = 2.0  # 当前生成间隔
var game_time: float = 0.0  # 游戏进行时间

func _ready():
	# 将生成器添加到游戏管理器组
	add_to_group("game_manager")
	
	# 初始化生成间隔
	current_spawn_interval = spawn_interval

func _physics_process(delta):
	if not is_game_running:
		return
	
	# 更新游戏时间（用于难度递增）
	game_time += delta
	
	# 更新难度（如果启用）
	if difficulty_scaling:
		update_difficulty(delta)
	
	# 更新计时器
	spawn_timer += delta
	
	# 当计时器达到当前生成间隔时，生成新管道
	if spawn_timer >= current_spawn_interval:
		spawn_pipe_pair()
		spawn_timer = 0.0
		
		# 如果使用随机间隔，计算下一个间隔
		if use_random_interval:
			current_spawn_interval = randf_range(spawn_interval_min, spawn_interval_max)
		elif not difficulty_scaling:
			# 如果不使用随机间隔且不启用难度递增，使用固定间隔
			current_spawn_interval = spawn_interval

func spawn_pipe_pair():
	# 生成新的管道对
	if pipe_pair_scene:
		var pipe_pair = pipe_pair_scene.instantiate()
		add_child(pipe_pair)
		
		# 计算安全的Y位置范围
		var safe_y_range = calculate_safe_y_range(pipe_pair)
		
		# 设置管道位置
		pipe_pair.position.x = spawn_x
		pipe_pair.position.y = randf_range(safe_y_range.x, safe_y_range.y)
		
		print("生成新管道对，Y位置: ", pipe_pair.position.y, " 当前间隔: ", current_spawn_interval, " 秒")

func update_difficulty(delta):
	# 更新难度（减少生成间隔）
	if difficulty_scaling:
		var new_interval = current_spawn_interval - difficulty_speed * delta
		current_spawn_interval = max(new_interval, spawn_interval_min)
		
		# 每5秒输出一次当前难度信息
		if int(game_time) % 5 == 0 and int(game_time) > 0:
			print("当前难度 - 生成间隔: ", current_spawn_interval, " 秒, 游戏时间: ", int(game_time), " 秒")

func get_current_spawn_interval() -> float:
	# 获取当前生成间隔
	return current_spawn_interval

func set_spawn_interval(new_interval: float):
	# 设置生成间隔
	spawn_interval = new_interval
	if not use_random_interval and not difficulty_scaling:
		current_spawn_interval = new_interval

func reset_difficulty():
	# 重置难度
	current_spawn_interval = spawn_interval
	game_time = 0.0
	print("难度已重置，生成间隔: ", current_spawn_interval, " 秒")

func calculate_safe_y_range(pipe_pair: Node2D) -> Vector2:
	# 获取管道高度（在函数开始时就获取，避免重复声明）
	var pipe_height = 480.0  # 默认管道高度
	if pipe_pair.has_method("get_gap_config"):
		var config = pipe_pair.get_gap_config()
		pipe_height = config.pipe_height
	
	# 如果使用手动配置的边界范围
	if not use_auto_boundary:
		# 手动模式下也要考虑下管道顶部不超过400像素的限制
		var manual_min_y = max(min_pipe_y, screen_margin + pipe_height / 2)
		var manual_max_y = min(max_pipe_y, 400.0 - pipe_height / 2)
		print("使用手动配置的边界范围: ", manual_min_y, " - ", manual_max_y, " (地面高度: ", ground_height, ")")
		return Vector2(manual_min_y, manual_max_y)
	
	# 获取管道的间隙配置
	var gap_size_min = 120.0  # 默认最小间隙
	var gap_size_max = 200.0  # 默认最大间隙
	
	# 尝试从管道对获取实际配置
	if pipe_pair.has_method("get_gap_config"):
		var config = pipe_pair.get_gap_config()
		gap_size_min = config.gap_min
		gap_size_max = config.gap_max
	
	# 新的边界计算逻辑：基于可用空间和约束条件
	# 计算可用的垂直空间
	var available_height = screen_height - 2 * screen_margin
	
	# 计算管道和间隙占用的总高度
	var total_pipe_height = pipe_height * 2  # 上下管道总高度
	var total_required_height = total_pipe_height + gap_size_max
	
	# 检查是否有足够的空间
	if total_required_height > available_height:
		print("警告：所需高度(", total_required_height, ")超过可用空间(", available_height, ")，将调整间隙大小")
		# 如果空间不足，使用最小间隙
		gap_size_max = gap_size_min
	
	# 重新计算所需高度
	total_required_height = total_pipe_height + gap_size_max
	
	# 计算管道中心的理论范围
	# 上管道顶部不能超出屏幕顶部太多
	var min_center_y = screen_margin + pipe_height / 2
	
	# 下管道顶部不能超过400像素
	var max_center_y = 400.0 - pipe_height / 2
	
	# 检查理论范围是否有效
	if min_center_y >= max_center_y:
		print("警告：理论范围无效，将使用屏幕中心作为基准")
		# 如果理论范围无效，使用屏幕中心作为基准
		var screen_center_y = screen_height / 2
		var max_range = (available_height - total_required_height) / 2
		
		if max_range > 0:
			min_center_y = screen_center_y - max_range
			max_center_y = screen_center_y + max_range
		else:
			# 如果连最小范围都没有，使用固定值
			min_center_y = screen_center_y - 50
			max_center_y = screen_center_y + 50
			print("警告：使用固定范围")
	
	# 应用安全系数
	var center_y = (min_center_y + max_center_y) / 2
	var range_half = (max_center_y - min_center_y) / 2 / boundary_safety_factor
	
	var safe_min_y = center_y - range_half
	var safe_max_y = center_y + range_half
	
	# 最终边界检查
	safe_min_y = max(safe_min_y, screen_margin + pipe_height / 2)
	safe_max_y = min(safe_max_y, 400.0 - pipe_height / 2)
	
	print("自动计算安全Y范围: ", safe_min_y, " - ", safe_max_y, " (屏幕高度: ", screen_height, ", 地面高度: ", ground_height, ", 管道高度: ", pipe_height, ", 最大间隙: ", gap_size_max, ", 安全系数: ", boundary_safety_factor, ")")
	
	return Vector2(safe_min_y, safe_max_y)

func clear_all_pipes():
	# 清除所有管道
	for child in get_children():
		if child.is_in_group("pipes") or "PipePair" in child.name:
			child.queue_free()

func game_over():
	# 游戏结束时停止生成
	is_game_running = false

func start_game():
	# 游戏开始时重新开始生成
	is_game_running = true
	spawn_timer = 0.0
	clear_all_pipes()
	
	# 重置难度
	reset_difficulty()
